Method and system for providing flexible time-based control of application appearance and behavior

ABSTRACT

A method, a computer readable medium, and a system are provided for controlling computer system operation during execution of the computer system. At least one attribute change of a computer system to occur during the execution of the computer system is identified. The attribute change is associated with a state change in the computer system such that indication of the state change triggers the attribute change. An index point is identified at which point the state change is to occur. The state change is associated with the index point, and when the index point is reached during the course of computer system execution, the attribute change is triggered automatically upon the index point being reached. The method, computer readable medium, and system can be used for controlling computer system execution in a broadcast environment or used to emulate computer system execution.

FIELD OF THE INVENTION

[0001] This invention relates generally to computer softwareapplications and, more specifically, to timing, control, and executionof software applications.

BACKGROUND OF THE INVENTION

[0002] The improved price-performance of digital technology has madepossible the advent of digital media broadcasting. The reduced cost ofmicroprocessors, digital memory, and related devices has made itpossible to place computers in set-top boxes (STBs) and related devicesto receive digital cable or digital satellite television signals anddecode those signals into audio-visual programs.

[0003] The advent of digital television broadcasting and theproliferation of STBs also makes it possible to enhance viewers'television experiences. In addition to transmitting video and audiodata, digital media broadcasting allows additional data to betransmitted to the STBs with which users can interact. By analogy, userscan interact through an STB with data transmitted via the digital mediabroadcast the way a computer user can interact with data available overthe Internet. For example, digital television subscribers are alreadyacquainted with an electronic program guide (EPG) function which enablesusers to select and tune to particular programs and/or read about theprograms being shown at present or at later points in time.

[0004] The EPG is a rudimentary example of an interactive televisionapplication exploiting the capability of the digital broadcast medium totransmit additional content and for the STB to execute this additionalcontent. The computer functionality of STBs also makes other interactivetelevision applications possible. With appropriately configured STBs,users potentially can play along with game shows, take tests in on-linedistance learning courses, bid in on-line auctions, and otherwiseactively engage the content being broadcast. STBs thus allow users tohave highly interactive television experiences.

[0005] One type of additional content application which is desirable insuch a broadcast environment is one which provides functionalitysynchronized with video or audio content on a broadcast channel. In theexamples of interactive game shows, on-line distance learning testing,and on-line auctions, it would be highly desirable to provideapplication-specific behaviors in an STB which are correlated toassociated video and audio streams being broadcast. Providingapplication-specific behaviors in the STB and correlating theapplication-specific behaviors with video and audio streams presents anumber of concerns. These concerns, and conventional responses to theseconcerns are described in detail in the co-pending patent applicationsincorporated by reference. Nonetheless, at least two of these concernsmerit repeating.

[0006] First, providing application specific behaviors to STBsconventionally involves transmitting application-specific program codeto the STBs. The transmission would be carried through the digitalbroadcast medium, just as video and audio data are transmitted.Downloading such applications involves transmitting potentially manydata packets, comprising vast numbers of data blocks, for eachapplication. A concern arises because video and audio data for thenumerous channels being transmitted leaves little bandwidth for otherdata. Thus, it may be difficult to procure the bandwidth necessary totransmit large bodies of application specific programming to supportdesired behaviors in STBs. Moreover, STBs may have relatively littlerandom access memory (RAM) in which to store significant applications.

[0007] Second, synchronizing behaviors of the application specificprogramming with a series of events in the video and audio data can bedifficult. Applications of this type conventionally use asynchronoustrigger signals embedded in the broadcast signal. These asynchronoustrigger signals can be difficult to deliver accurately when data blockscarrying such triggers must be multiplexed with so much other video andaudio data transmitted in the medium. Further, these time-dependenciespresent particular concerns when a user engages a program already inprogress and may have missed a timing synchronization event at theoutset of the program. Correlating the application-specific programmingwith the video and audio stream may be troublesome, if even possible.

[0008] Developers of interactive programming or other programs for whichit is desired to transmit additional content to go along with video andaudio data are suitably concerned with how to provide and correlatetiming of such content. It is highly desirable to develop support inSTBs to reduce data transmission needs and to allow for correlation ofapplication behaviors. Correspondingly, it is highly desirable fordevelopers to be able to test and modify applications to ensure thatthey will operate appropriately in the STB environment, and that thetiming of events in such applications is appropriate. Similarly, it ishighly desirable to be able to emulate program execution to monitormemory usage and other attributes of the applications to make sure thatthe applications will run properly on STBs. It is important thatdevelopers be able to review important portions of applications, and beable to make desired modifications.

[0009] Thus, there are unmet needs in the art for facilitating efficienttransfer of data in a broadcast environment that allows for accuratelysynchronized behavior by an application, as well as for testing,monitoring, and modifying such applications prior to transmission toensure desired execution by users.

SUMMARY OF THE INVENTION

[0010] Embodiments of the present invention enable provide support forcontrolling program appearance and behavior during execution of acomputer system. Behavioral attribute changes are correlated with statechanges which are associated with a list of triggering events whichinitiate the behavioral changes. As a result, applications can begenerated with provision of data in the form of collections of statechanges and event lists without having to generate or provide customapplication code.

[0011] More specifically, embodiments of the present invention provide amethod, a computer readable medium, and a data system for controllingcomputer system operation during execution of the computer system. Usingembodiments of the present invention, at least one attribute change of acomputer system to occur during execution of the computer system isidentified. The attribute change is associated with a state changeoccurring in the computer system such that the state change initiatesthe attribute change. Index points are identified in the execution ofthe computer system indicative of when the state change is to occur.These index points are associated with appropriate state changes. Uponexecution of the computer system, reaching events associated with theindex points triggers the associated state changes and, thus, theassociated attributes are changed automatically upon reaching theappropriate index points.

[0012] Embodiments of the present invention suitably operate in abroadcast environment where execution of the computer system iscorrelated with a media program, and the media program and dataconcerning attribute changes and index points are broadcast via digitaltransmission. Embodiments of the present invention also suitably operatein an emulation environment where the media program and data concerningattribute changes and index points are loaded into an emulator wheretheir presentation can be tested, monitored, and revised if necessary.

[0013] In accordance with further aspects of the invention, the indexpoints are collected into index tables, and the state changes arecollected in state tables. The index table and the associated statetable can be modified, updated, and/or transmitted independently of oneanother, and can be separately or sequentially loaded from a data streamcontaining the index table and the state table. The index table andstate table can be received from a broadcast network and viewed at thattime or stored for later execution. The index table and state table alsocan be stored directly on a system and executed in an emulationenvironment to monitor application behaviors according to an emulatedpassage of time. The emulated passage of time can be modified toscrutinize resulting behaviors to allow for monitoring of applicationparameters, and to allow for modification of the index table and statetable to adjust application behaviors.

BRIEF DESCRIPTION OF THE DRAWINGS

[0014] The preferred and alternative embodiments of the presentinvention are described in detail below with reference to the followingdrawings.

[0015]FIG. 1 shows a timeline of event triggers driving an index tableand a state table for controlling an interactive software applicationaccording to an embodiment of the present invention;

[0016]FIG. 2 is a flowchart of a routine for executing state changes andindex points in an index table according to an embodiment of the presentinvention;

[0017]FIG. 3 is a flowchart of a routine for emulating state changes andindex points in an index table according to an embodiment of the presentinvention;

[0018]FIG. 4 is a is a set of windows for reviewing and revisingattribute changes and index points;

[0019]FIG. 5 is a block diagram of an environment for creating,disseminating and using applications using an embodiment of the presentinvention;

[0020]FIG. 6 is a block diagram of an interpreter executing anapplication using state changes and index points in accordance with anembodiment of the present invention; and

[0021]FIG. 7 is a block diagram of a data processing/media controlsystem for executing or emulating applications according to anembodiment of the present invention.

DETAILED DESCRIPTION OF THE INVENTION

[0022] By way of overview, embodiments of the present invention providea method, a computer readable medium, and a data system for controllingcomputer system operation during execution of the computer system. Usingembodiments of the present invention, at least one attribute change of acomputer system to occur during execution of the computer system isidentified. The attribute change is associated with a state changeoccurring in the computer system such that the state change initiatesthe attribute change. Index points are identified in the execution ofthe computer system indicative of when the state change is to occur.These index points are associated with appropriate state changes. Uponexecution of the computer system, reaching events associated with theindex points triggers the associated state changes and, thus, theassociated attributes are changed automatically upon reaching theappropriate index points. Embodiments of the present invention suitablyoperate in a broadcast environment where execution of the computersystem is correlated with a media program, and the media program anddata concerning attribute changes and index points are broadcast viadigital transmission. Embodiments of the present invention also suitablyoperate in an emulation environment where the media program and dataconcerning attribute changes and index points are loaded into anemulator where their presentation can be tested, monitored, and revisedif necessary.

[0023]FIG. 1 shows exemplary interaction between a video timeline 102for a program with identified events 104, 106, 108, and 110, an indextable 112, a plurality of state changes collected in a state table 114,and a program display 116 in one embodiment of the invention that isgiven by way of a non-limiting example. The operation of the statechanges stored in the state table 114, the operation of the index pointscontained in the index table 112, and a facility for generating suchcontrol information as manifested in the tables 112 and 114 are furtherdescribed in the concurrently-filed, co-pending patent applicationsentitled “METHOD AND SYSTEM FOR AUTOMATIC CONTROL OF GRAPHICAL COMPUTERAPPLICATION APPEARANCE AND EXECUTION,” bearing attorney docket numberENSE-1-1003, “METHOD AND SYSTEM FOR FLEXIBLE TIME-BASED CONTROL OFAPPEARANCE AND BEHAVIOR OF SOFTWARE APPLICATION,” bearing attorneydocket number ENSE-1-1004, and “METHOD AND SYSTEM FOR GENERATINGFLEXIBLE TIME-BASED CONTROL OF APPLICATION APPEARANCE AND BEHAVIOR,”bearing attorney docket number ENSE-1-1010, respectively, the contentsof which are hereby incorporated by reference.

[0024] The video timeline 102 depicts four sequences in the program,including an introduction 124, Part 1 126, Part 2 128, and Part 3 130.The beginnings of these sequences 124, 126, 128, and 130 are identifiedas events 104, 106, 108, and 110, respectively, to be used incorrelating presentation of additional content. The events 104, 106,108, and 110 are thus associated with index points 174, 176, 178, and181 and collected in the index table 112 in sequential order. In turn,each of the index points 174, 176, 178, and 181 are associated with astate 144, 146, 148, and 150, respectively, in the state table 114. Thestate table 114 also lists three program attributes 164, 166, and 168which control appearance and behavior of the program as shown on theprogram display 116. As a result, as the video timeline 102 progresseswith presentation of the program, each of the events 104, 106, 108, and110 are reached. Reaching each of these events 104, 106, 108, and 110triggers index points 174, 176, 178, and 181, respectively, in the indextable 112. Reaching index points 174, 176, 178, and 181 in the indextable 112 triggers state changes to states 144, 146, 148, and 150,respectively, thereby potentially changing each of the programattributes appearing on the program display 116.

[0025] More specifically, as represented on the video timeline 102, theprogram commences at a beginning associated with event 104. The event104, which occurs at “frame 0” at the beginning of the program, isassociated with index point 174 and state 144, which is a first state inthe state table 114. At the state 144, a program attribute “btn.visible”180 is set to “T” 182 for true, thereby making a button 184 appear onthe program display 116. A program attribute “image.file” 186 is set to“a” 188, thereby making an associated image 190 appear on the programdisplay. A program attribute “screen.color” 192 is set to “6” 194,changing a color of a background on the program display 116.

[0026] The program continues to progress according to the video timeline102 and reaches the event 106 which occurs at “frame i” at the beginningof a next segment of the program. The event 106 occurs at “frame i” andis associated with index point 176 and state 146. Thus, upon reachingevent 106, index point 176 automatically triggers the state change tostate 146. At the state 146, the program attribute “btn.visible” 180 isset to “F” 196 for false, thereby making the button 184 disappear fromthe program display 116. The program attribute “image.file” 186 is setto “b” 198, making an associated image (not shown) appear on the programdisplay in the place of image 190. The program attribute “screen.color”192 is set to “8” 199, again changing a color of a background on theprogram display. Similarly, as the events 108 at “frame j” and 110 at“frame k” are reached, index points 178 and 181, respectively, triggerstate changes in the state table 114 to the states 148 and 150,respectively, thereby changing the appearance and behavior of theprogram as evidenced by the appearance of the display screen 116. Insum, when events logged as index points are reached during execution ofthe program, states changes associated with the index points aretriggered, initiating associated attribute changes.

[0027] It will be appreciated that execution of an application asdescribed by the non-limiting example advantageously can be performedupon actual execution of the application at a viewer/user location or inemulating the execution of the application prior to dissemination of theapplication. In the former case, the application might be executed by aSTB which first loads the state change and index point information, thenexecutes the state changes according to the index points. In the lattercase, the application might be executed on a computer emulating the STBenvironment by loading the state change and index point information andallowing program developers or editors to monitor how the applicationwill execute in a view/user environment. FIGS. 2 and 3 show routines forhow such execution and emulation, respectively, can be performedaccording to embodiments of the present invention.

[0028]FIG. 2 shows a flowchart of a routine 200 for executing anapplication implemented using a series of state changes and index pointscollected in a state table and an index table, respectively. In thisnon-limiting example, the routine can be conceived as executing in a STBsuitably coupled with a television or other monitoring equipment. Theroutine commences at a block 210. At a block 220, a state table isloaded, the state table listing the state changes which define thebehaviors of the application. At a block 230, an index table is loaded.The index table lists the index points which trigger state changeslisted in the state table. It will be appreciated that either theloading of the state table at the block 220 or the loading of the indextable at the block 230 may be performed first. In addition, if either acurrent state table or a current index table is already resident in theSTB, only that table which was not previously loaded is loaded in theroutine. Thus, if current versions of both tables already are loaded inthe STB, neither need be loaded again. It will be appreciated,therefore, that if one of the tables is updated or revised, only therevised table would have to be received. Accordingly, only the revisedtable would have to be transmitted, thereby saving on bandwidth.

[0029] It will also be appreciated that, while the attribute changes arecorrelated into state changes and collected in a state table,information determining the attribute changes also could be collected inobject-specific lists and other forms. Similarly, while index pointshave been collected into index tables for purposes of this non-limitingexample, index points also could be collected into index lists orpresented in other ways. For clarity and brevity of explanation, theterm state table is used to refer to a collection of statechange/attribute change data, and the term index table is used to referto a collection of index point data.

[0030] Once the state table and index table have been loaded, programsequence execution is initiated at a block 240. If the viewer or userhas engaged the program at the time of program broadcast, initiation ofthe program sequence at the block 240 could be triggered at a broadcastsite. Alternatively, if the viewer or user later engages the programtime from a recording device, that same program initiation signalembedded in the broadcast suitably initiates program execution uponreplaying of the broadcast. In any case, initiation of program executionthen begins a passage of time or a sequence of events which correspondwith the index points received in the index table, thereby facilitatingprogram execution.

[0031] As the program executes, video and/or audio information isdecoded and presented to the user, along with any continuous contentstored in the data included with the program. When an index point isreached at a decision block 250, associated state or attribute changesare made at a block 260. Again, the operations of state tables and indexpoints are further described in the concurrently-filed, co-pendingpatent applications entitled “METHOD AND SYSTEM FOR AUTOMATIC CONTROL OFGRAPHICAL COMPUTER APPLICATION APPEARANCE AND EXECUTION,” bearingattorney docket number ENSE-1-1003, and “METHOD AND SYSTEM FOR FLEXIBLETIME-BASED CONTROL OF APPEARANCE AND BEHAVIOR OF SOFTWARE APPLICATION,”bearing attorney docket number ENSE-1-1004, respectively, the contentsof which are hereby incorporated by reference. If index points are notbeing reached at the decision block 250, the routine checks to see ifthe last index point has been reached at a decision block 270. If not,the routine loops to the decision block 250 until an index point isreached at the decision block 250 or a last index point is reached atthe decision block 270. If a last index point is reached at the decisionblock 270, the application ends at a block 280.

[0032]FIG. 3 is a flowchart of a routine 300 for emulating execution ofthe application. The routine 300 commences at a block 310 and, like theroutine 200 (FIG. 2) starts by loading a state table at a block 320 andloading an index table at a block 330. It will be appreciated thatloading of either table could proceed first. It will also be appreciatedthat, in an emulator environment, the tables likely will be loaded froma local storage device rather than received from a broadcast medium. Fora non-limiting example, the routine 300 suitably is executed on acomputer on which the state table and index table have been stored on ahard disk or other recording medium. The computer suitably may be thesame device on which the application and tables previously have beencreated.

[0033] Once the tables are loaded, at a block 340, execution parametersare monitored. These parameters suitably include utilization of memoryor other resources, execution time and other-time related information,or other parameters. Allowing an operator to monitor these parametersallows the operator to further ensure proper run-time behavior once theapplication is broadcast.

[0034] At a block 350, the operator controls an emulated passage oftime. At the block 350, the operator can let the application executeaccording to an ordinary timing sequence that might be expected in abroadcast environment. Alternatively, the operator can execute theapplication in slow motion at a slower execution rate than wouldnormally be expected. Alternatively, the operator can execute theapplication one time unit or frame at a time. Alternatively, theoperator can execute the application more rapidly than would be expectedin a broadcast situation. Also, the operator can move backward as wellas forward through application execution to review to his or hersatisfaction operation of the application.

[0035] As the passage of time is emulated, at a decision block 360 it isdetermined if an index point has been reached. Once an index point hasbeen reached, at a block 370 the associated behavioral changes,including state changes, are executed. At a decision block 380, theoperator determines whether the behavioral changes resulting from theinteraction of the state changes in the state table, the index points inthe index table, and the emulated passage of time yield an acceptableresult. If the result is acceptable, the operator continues with thecontrol of the emulated passage of time at the block 350 to furtheremulate the application. If the result is not acceptable, at a decisionblock 380, the operator can revise the state changes in the state tableor the index points in the index table to modify the execution of theapplication. After making such modifications, the routine resumes withthe operator's control of the emulated passage of time at the block 350to further emulate application execution. In this way, the operator canexecute an aspect of the application that was just revised to determineif the revisions are acceptable. The operator can continue with theemulated control of time at the block 350 indefinitely, or the operatorcan choose to terminate emulation of the application at any time (notshown).

[0036]FIG. 4 shows an exemplary embodiment of a monitoring environment470 in which the routine of FIG. 3 suitably is implemented for emulatingexecution of the application. The emulating environment includes aviewing window 472 for showing the program including attribute changes474 generated. An application icon 476 is situated on the screen tosignal to a viewer that the object on the screen marked by theapplication icon 476 is of interest to him or her. An application icon476 can be used, for example, to signal a viewer interactionopportunity, such as the user having a chance to purchase the itemmarked with the application icon 476 through the use of his or herkeyboard or remote control. An application window allows 478 allows fortext- and command-drive manipulation of code associated with theattribute changes, if the developer desires to make changes beyond or inaddition to those that can be made through manipulation of the tables. Astatus window 480 textually presents a list of functions being executedto present the attribute changes shown so that the developer can monitorwhat is causing the attributes shown on the screen.

[0037] For testing interactive programs, a recording window 482 and aremote window 484 are provided. The developer can simulate how a vieweror user of an interactive program might interact with a STB or otherdevice to engage the program. For example, if a program such as acooking show offers opportunities to purchase merchandise, the developercan click on a screen button 485 to simulate a user making a choice on akeypad. As a result, this allows the developer to determine how wellinteractive attribute changes he or she created will function.Similarly, the recording window 482 records actions of the simulateduser to allow the interactive program to be played back to review howwell the interactive functionality operated. A resource monitoringwindow 486 also allows the developer to monitor system resource usage,such as memory usage, to determine whether the program meets practicalconstraints and objectives.

[0038]FIG. 5 shows a block diagram of an exemplary system embodiment ofthe present invention in a production and broadcast environment.Applications are created in an authoring environment 510. Suitably, theapplications are emulated there according to the routine 300 (FIG. 3) todetermine if they will execute satisfactorily in a broadcastenvironment. Once the application has been satisfactorily authored inthe authoring environment 510, the application is disseminated in abroadcast environment 520. As previously described, digital applicationscan be transmitted via digital cable transmission, digital satellitetransmission, or also may be transmitted via the Internet or othermeans. The application, including the state changes and the index points(not shown) are received at an STB 530 where they are processed by aninterpreter 540 executing in the STB 530. The interpreter 540 receivesand processes the state changes and index points, such as in the mannerdescribed in the routine 200 (FIG. 2). The output of the interpreter 540is presented to a user or viewer via a monitor 550, which suitably is atelevision, an audiovisual monitor, a computer, or another deviceequipped to process the application.

[0039] As previously described, interaction with an application ispossible through the interpreter 540 and the STB 530. Applicationssuitably allow for interaction not only at the STB 530 level, but alsoat a broadcast site level, as in the examples of on-line testing,on-line auctions, and similar applications. In such cases, a return path560 allows for user/viewer input back to the broadcast site which can beincorporated by a dynamic transmission processor 570 responsive touser/viewer input. For example, if the application invites viewers totake place in an on-line poll, votes gathered by the interpreter 540 canbe transmitted via the STB 530 over the return path 560 to the dynamictransmission processor 570 where the poll can be tallied. Results can berelayed via a live host or, if the audiovisual portion of the program isprerecorded, the results could be encoded as data and processed by theinterpreter 540 in the STB 530 to be presented to the user. It will beappreciated that the return path 560 for digital STBs suitably is aphone line through which users order pay-per-view movies and throughwhich other transactions are processed. The return path 560 could be aphone line, a return band through the digital broadcast medium, oranother implementation.

[0040] It will be appreciated that the application could be emulated bya system capable to mimic the functions of the STB 530 and theinterpreter 540. In an emulation environment, the application would notbe broadcast, but instead it would be loaded from a local medium andexecuted. Functions of the dynamic processor 570 in response to useractions could be simulated locally as well.

[0041]FIG. 6 shows a block diagram of one presently preferred embodimentof the interpreter 540. The interpreter 540 processes index points 602and state changes collected in a state table 606 via an execution model604. The execution model 604 contains standard function calls tointerpret functions invoked in the state table. The execution model 604also is responsive to the index points to sequence through the statetable as dictated by the application behaviors encoded in the statetable 606. In one presently preferred embodiment, as the execution model604 steps through each state change in the state table, specifiedoperands in the state changes are pushed onto an execution stack 608. Abyte code interpreter 610 then retrieves these operands which, fornon-limiting examples, can be values or additional function code. Thebyte-code interpreter 610 then implements the behaviors that wereencoded in the state table 606, triggered by the index points 602, anddirected by the execution model 604 to the execution stack 608.

[0042]FIG. 6 does not show a clock or other synchronizing device,although it will be appreciated that some indication of passage of time,whether a frame number count, elapsed time, or other such indicator isdesired to drive execution of the computer system. For stored programsand data, a system clock, reading of frame or other sequence numbers, orsimilar means can be used to drive execution of the system in astandalone or emulation environment. In a broadcast environment, time orframe indicators would be broadcast or a system clock suitablysynchronized to a broadcast time or counter could be used to driveexecution of the computer system.

[0043]FIG. 7 shows a computer system 700, which could be in the form ofa media controller, STB, or emulator station operable for usingembodiments of the present invention. The computer system 700 isoperable for controlling a display 702, such as a television, and anaudio subsystem 704, such as a stereo or a loudspeaker system. Thecomputer system 700 receives input from a network or storage 706 in thecase of the STB or the emulator station, respectively. The computersystem 700 also receives user input from a wired or wireless user keypad708, which may be in the nature of a STB remote, a computer keyboard, oranother input device.

[0044] The computer system 700 receives input via an input/outputcontroller 710, which directs signals to and from a video controller712, an audio controller 714, and a central processing unit (CPU) 716.In the case of a STB, the input/output controller 710 suitably is amultiplexer for routing video data blocks received to a video controller712 in the nature of a video decoder, audio data blocks to an audiocontroller 714 in the nature of an audio decoder, and for routing otherdata blocks to a CPU 716 for processing. In turn, the CPU 716communicates through a system controller 718 with input and storagedevices such as read only memory (ROM) 720, system memory 722, systemstorage 724, and input device controller 726.

[0045] The computer system 700 shown in FIG. 7 thus can receive statechanges collected in state tables and index points collected in indextables and pass them through the input/output controller 710 to the CPU716 where they will be processed through the system controller 718,suitably in response to user input gathered through the user keypad 708and the input device controller 726. The state changes collected in thetable can then be executed and/or modified as triggered by the indexpoints in the index table as previously described in connection with theforegoing example, method flowcharts, block diagrams, and co-pendingpatent applications incorporated by reference. User input or emulateduser input can be returned by the input device controller 726 throughthe system controller 718 to the CPU 716 for processing. In turn, theCPU 716 transmits the information through the input/output controller710 to the network or storage 706 as appropriate.

[0046] While the preferred embodiment of the invention has beenillustrated and described, as noted above, many changes can be madewithout departing from the spirit and scope of the invention.Accordingly, the scope of the invention is not limited by the disclosureof the preferred embodiment. Instead, the invention should be determinedentirely by reference to the claims that follow.

What is claimed is:
 1. A method for controlling computer systemoperation during execution of the computer system, the methodcomprising: identifying at least one attribute change of a computersystem to occur during execution of the computer system; associating theattribute change with a state change in the computer system such thatindication of the state change triggers the attribute change;identifying an index point in the execution of the computer systemindicative of when the state change is to occur; associating the indexpoint in the computer system with the state change; and triggering thestate change in the computer system upon reaching the index pointassociated with the state change, such that the attribute is changedautomatically upon the index point being reached.
 2. The method of claim1, wherein each of the index points associated with the state changes iscollected in an index table.
 3. The method of claim 2, wherein the indextable includes a first column listing the index points and a secondcolumn listing the associated state changes.
 4. The method of claim 2,wherein the index table is ordered by sequential occurrence of the indexpoints.
 5. The method of claim 1, wherein state changes for attributechanges are collected in a state table, the state table listing theattribute changes along a first dimension of the state table and thestate changes along a second dimension of the state table such that aseach current state change is reached, each attribute change associatedwith the current state change is triggered.
 6. The method of claim 5,wherein the index table and the state table are revisable independentlyof each other such that changing one of the index table or the statetable does not necessitate changing both the index table and the statetable.
 7. The method of claim 5, further comprising one of sequentiallyloading or separately loading the index table and its associated statetable from a data stream received by the computer system.
 8. The methodof claim 1, wherein the execution of the computer system is based on asequence of state changes and index points received from a broadcastnetwork.
 9. The method of claim 8, wherein the sequence of state changesand the index points are received from the broadcast network and storedfor subsequent execution.
 10. The method of claim 1, wherein theexecution of the computer system is based on a sequence of state changesand index points stored on the computer system.
 11. The method of claim10, wherein passage of time for controlling the execution of thecomputer system is emulated and is manipulable for emulating actualexecution of the computer system during actual passage of time.
 12. Themethod of claim 11, wherein parameters for emulating actual execution ofthe computer system are monitorable.
 13. The method of claim 12, whereinthe parameters include execution running time.
 14. The method of claim12, wherein the parameters include memory usage.
 15. The method of claim11, wherein the sequence of state changes and index points is revisablefor controlling the execution of the computer system during the actualpassage of time.
 16. A method for controlling computer system operationduring execution of the computer system, the method comprising: runningan execution manager including: receiving external data that determinesat least a first set of behaviors of execution of a computer system;executing a plurality of functions responsive to the external datareceived; and processing the external data, the external data including:a state table configured to collect a plurality of attribute changesoccurring during execution of the computer system, the state table beingfurther configured to assign the attribute changes to a plurality ofstate changes; and a series of index points triggering the state changesin the state table upon the occurrence of events occurring duringexecution of the computer system.
 17. The method of claim 16, whereineach of the index points associated with the state changes is collectedin an index table.
 18. The method of claim 17, wherein the index tableincludes a first column listing the index points and a second columnlisting the associated state changes.
 19. The method of claim 17,wherein the index table is ordered by sequential occurrence of the indexpoints.
 20. The method of claim 16, wherein the state table lists theattribute changes along a first dimension of the state table and thestate changes along a second dimension of the state table such that aseach current state change is reached, each attribute change associatedwith the current state change is triggered.
 21. The method of claim 20,wherein an index point type for the attribute change is specified withinthe state table at an intersection of each attribute change associatedwith each state change.
 22. The method of claim 17, wherein the indextable and the state table are revisable independently of each other suchthat changing one of the index table or the state table does notnecessitate changing both the index table and the state table.
 23. Themethod of claim 17, further comprising one of sequentially loading orseparately loading the index table and its associated state table from adata stream received by the computer system.
 24. The method of claim 17,wherein at least one of the state table and the index table is receivedfrom a broadcast network.
 25. The method of claim 24, wherein the atleast one of the state table and the index table is received from thebroadcast network and stored for subsequent execution.
 26. The method ofclaim 16, wherein the state table and the index table are stored on thecomputer system.
 27. The method of claim 26, wherein passage of time forcontrolling the execution of the computer system is manipulable foremulating actual execution of the computer system during actual passageof time.
 28. The method of claim 27, wherein parameters for emulatingactual execution of the computer system are monitorable.
 29. The methodof claim 28, wherein the parameters include execution running time. 30.The method of claim 28, wherein the parameters include memory usage. 31.The method of claim 27, wherein the sequence of state changes and indexpoints revisable for modifying the execution of the computer systemduring the actual passage of time.
 32. A computer readable medium forcontrolling computer system operation during execution of the computersystem, the computer readable medium comprising: first computer programcode means for identifying at least one attribute change of a computersystem to occur during execution of the computer system; second computerprogram code means for associating the attribute change with a statechange in the computer system such that indication of the state changetriggers the attribute change; third computer program code means foridentifying an index point in the execution of the computer systemindicative of when the state change is to occur; fourth computer programcode means for associating the index point with the state change; andfifth computer program code means for triggering the state change in thecomputer system upon reaching the index point associated with the statechange, such that the attribute is changed automatically upon the indexpoint being reached.
 33. The computer readable medium of claim 32,further comprising sixth computer program code means for collecting inan index table each of the index points associated with the statechanges by the fourth computer program code means.
 34. The computerreadable medium of claim 33, wherein the sixth computer program codemeans generates the index table with a first column listing the indexpoints and a second column listing the associated state changes.
 35. Thecomputer readable medium of claim 33, wherein the sixth computer programcode means orders the index table by sequential occurrence of the indexpoints.
 36. The computer readable medium of claim 32, further comprisingseventh computer program code means for collecting state changesassociated with the attribute changes by the second computer programcode means in a state table, the state table listing the attributechanges along a first dimension of the state table and the state changesalong a second dimension of the state table such that as each currentstate change is reached, each attribute change associated with thecurrent state change is triggered.
 37. The computer readable medium ofclaim 36, further comprising eighth computer program code means forproviding for independently revising the index table and the state tablesuch that changing one of the index table or the state table does notnecessitate changing both the index table and the state table.
 38. Thecomputer readable medium of claim 36, further comprising ninth computerprogram code means for providing one of sequentially loading orseparately loading the index table and its associated state table from adata stream received by the computer system.
 39. The computer readablemedium of claim 32, further comprising tenth computer program code meansreceiving the sequence of state changes and index points from abroadcast network.
 40. The computer readable medium of claim 39, whereinthe tenth computer program code means stores the sequence of statechanges and the index points for subsequent execution.
 41. The computerreadable medium of claim 32, further comprising eleventh computerprogram code means for controlling the execution of the computer systembased on a sequence of state changes and index points stored on thecomputer system.
 42. The computer readable medium of claim 41, furthercomprising twelfth computer program code means for emulating passage oftime and manipulating the passage of time thereby allowing for emulatingactual execution of the computer system during actual passage of time.43. The computer readable medium of claim 42, further comprisingthirteenth computer program code means for monitoring parameters foremulating actual execution of the computer system.
 44. The computerreadable medium of claim 43, wherein the parameters include executionrunning time.
 45. The computer readable medium of claim 43, wherein theparameters include memory usage.
 46. The computer readable medium ofclaim 42, further comprising fourteenth computer program code means forrevising the sequence of state changes and index points to modify theexecution of the computer system during the actual passage of time. 47.A computer readable medium for controlling computer system operationduring execution of the computer system, the method comprising: firstcomputer program code means for running an execution manager including:second computer program code means receiving external data, the externaldata determining at least a first set of behaviors of execution of acomputer system; third computer program code means for executing aplurality of functions, the plurality of functions being responsive tothe external data received; and fourth computer program code means forprocessing the external data, the external data including: fifthcomputer program code means for collecting in a state table a pluralityof attribute changes occurring during the execution of the computersystem in a state table and assigning the attribute changes to aplurality of state changes; and sixth computer program code means forgenerating a series of index points triggering the state changes in thestate table upon occurrence of events occurring during execution of thecomputer system.
 48. The computer readable medium of claim 47, furthercomprising seventh computer program code means for collecting in anindex table each of the index points associated with the state changesby the sixth computer program code means.
 49. The computer readablemedium of claim 48, wherein the seventh computer program code meansgenerates the index table with a first column listing the index pointsand a second column listing the associated state changes.
 50. Thecomputer readable medium of claim 48, wherein the seventh computerprogram code means orders the index table by sequential occurrence ofthe index points.
 51. The computer readable medium of claim 47, furthercomprising an eighth computer program code means for collecting statechanges associated with the attribute changes by the fifth computerprogram code means in a state table, the state table listing theattribute changes along a first dimension of the state table and thestate changes along a second dimension of the state table such that aseach current state change is reached, each attribute change associatedwith the current state change is triggered.
 52. The computer readablemedium of claim 51, further comprising ninth computer program code meansfor independently revising the index table and the state table such thatchanging one of the index table or the state table does not necessitatechanging both the index table and the state table.
 53. The computerreadable medium of claim 51, further comprising tenth computer programcode means for one of sequentially loading or separately loading theindex table and its associated state table from a data stream receivedby the computer system.
 54. The computer readable medium of claim 47,further comprising eleventh computer program code means for receivingthe sequence of state changes and index points from a broadcast network.55. The computer readable medium of claim 54, wherein the eleventhcomputer program code means includes means storing the sequence of statechanges and the index points for subsequent execution.
 56. The computerreadable medium of claim 47, further comprising twelfth computer programcode means for controlling execution of the computer system based on asequence of state changes and index points stored on the computersystem.
 57. The computer readable medium of claim 56, further comprisingthirteenth computer program code means for emulating a passage of timeand manipulating passage of time thereby allowing for emulating actualexecution of the computer system during actual passage of time.
 58. Thecomputer readable medium of claim 57, further comprising fourteenthcomputer program code means for monitoring parameters for emulatingactual execution of the computer system.
 59. The computer readablemedium of claim 58, wherein the parameters include execution runningtime.
 60. The computer readable medium of claim 58, wherein theparameters include memory usage.
 61. The computer readable medium ofclaim 57, further comprising fifteenth computer program code means forrevising the sequence of state changes, and wherein index points arerevisable to modify execution of the computer system during actualpassage of time.
 62. A system for controlling computer system operationduring execution of the computer system, the system comprising: a userinterface including: a first component configured to identify at leastone attribute change of a computer system to occur during execution ofthe computer system; and a second component configured to associate theattribute change with a state change in the computer system such thatindication of the state change triggers the attribute change; and aprocessor including: a third component configured to identify an indexpoint in the execution of the computer system indicative of when thestate change is to occur; a fourth component configured to associate thefourth index point with the state change; and a fifth componentconfigured to trigger the state change in the computer system uponreaching the index point associated with the state change, such that theattribute is changed automatically upon the index point being reached.63. The system of claim 62, wherein the processor further includes asixth component configured to collect in an index table each of theindex points associated with the state changes.
 64. The system of claim63, wherein the sixth component is further configured to generate theindex table with a first column listing the index points and a secondcolumn listing the associated state changes.
 65. The system of claim 63,wherein the sixth component is further configured to order the indextable by sequential occurrence of the index points.
 66. The system ofclaim 62, wherein the processor further includes a seventh componentconfigured to collect in a state table state changes associated with theattribute changes, the state table listing the attribute changes along afirst dimension of the state table and the state changes along a seconddimension of the state table such that as each current state change isreached, each attribute change associated with the current state changeis triggered.
 67. The system of claim 66, wherein the processor furtherincludes an eighth component configured to independently revise theindex table and the state table such that changing one of the indextable or the state table does not necessitate changing both the indextable and the state table.
 68. The system of claim 66, wherein theprocessor further includes a ninth component configured to perform oneof sequentially loading or separately loading the index table and itsassociated state table from a data stream received by the computersystem.
 69. The system of claim 62, wherein the processor furtherincludes a tenth component configured to receive the sequence of statechanges and index points from a broadcast network.
 70. The system ofclaim 69, wherein the tenth component is further configured to store thesequence of state changes and the index points for subsequent execution.71. The system of claim 62, wherein the processor further includes aneleventh component configured to control execution of the computersystem based on a sequence of state changes and index points stored onthe computer system.
 72. The system of claim 71, wherein the processorfurther includes a twelfth component configured to emulate passage oftime and to manipulate the passage of time thereby allowing foremulating actual execution of the computer system during actual passageof time.
 73. The system of claim 72, wherein the processor furtherincludes a thirteenth component configured to monitor parameters foremulating of the actual execution computer system.
 74. The system ofclaim 73, wherein the parameters include execution running time.
 75. Thesystem of claim 73, wherein the parameters include memory usage.
 76. Thesystem of claim 72, wherein the processor further includes a fourteenthcomponent configured to revise the sequence of state changes and indexpoints to modify execution of the computer system during actual passageof time.
 77. A system for controlling computer system operation duringexecution of the computer system, the method comprising: a firstcomponent configured to run an execution manager including: a secondcomponent configured to receive external data, the external datadetermining at least a first set of behaviors of execution of a computersystem; a third component configured to execute a plurality of functionsbeing responsive to the external data received; and a fourth componentconfigured to process the external data, the external data including: astate table configured to collect a plurality of attribute changesoccurring during execution of the computer system, the state table beingfurther configured to assign attribute changes to a plurality of statechanges; and a series of index points triggering the state changes inthe state table upon occurrence of events occurring during execution ofthe computer system.
 78. The system of claim 77, further comprising afifth component configured to collect each of the index pointsassociated with the state changes by the sixth component in an indextable.
 79. The system of claim 78, wherein the fifth component isfurther configured to generate the index table with a first columnlisting the index points and a second column listing the associatedstate changes.
 80. The system of claim 78, wherein the fifth componentis further configured to order the index table by sequential occurrenceof the index points.
 81. The system of claim 77, further comprising asixth component configured to collect in a state table state changesassociated with the attribute changes, the state table listing theattribute changes along a first dimension of the state table and thestate changes along a second dimension of the state table such that aseach current state change is reached, each attribute change associatedwith the current state change is triggered.
 82. The system of claim 81,further comprising a seventh component configured to provide forindependently revising the index table and the state table such thatchanging one of the index table or the state table does not necessitatechanging both the index table and the state table.
 83. The system ofclaim 81, further comprising an eighth component configured to performone of sequentially loading or separately loading the index table andits associated state table from a data stream received by the computersystem.
 84. The system of claim 77, further comprising a ninth componentconfigured to receive the sequence of state changes and index pointsfrom a broadcast network.
 85. The system of claim 84, wherein the ninthcomponent is further configured to store the sequence of state changesand the index points for subsequent execution.
 86. The system of claim77, further comprising an tenth component configured to controlexecution of the computer system based on a sequence of state changesand index points stored on the computer system.
 87. The system of claim86, further comprising an eleventh component configured to emulatepassage of time and manipulate the passage of time thereby allowing foremulating actual execution of the computer system during actual passageof time.
 88. The system of claim 87, further comprising a twelfthcomponent configured to monitor parameters for emulating actualexecution of the computer system.
 89. The system of claim 88, whereinthe parameters include execution running time.
 90. The system of claim88, wherein the parameters include memory usage.
 91. The system of claim87, further comprising a thirteenth component configured to revise thesequence of state changes and index points to modify execution of thecomputer system during the actual passage of time.
 92. A method forcontrolling execution of a computer system during presentation of amedia program, the method comprising: receiving a media programincluding at least one of video content and audio content; receivingrelated data correlated with the media program for controlling computersystem execution during presentation of the media program; identifyingin the related data an attribute change to occur during presentation ofthe media program; identifying in the related data an index pointassociated with the attribute change for triggering the attribute changeupon detecting occurrence of the initiating event during presentation ofthe media program; presenting the media program; and detecting theinitiating event associated with the index point and triggering theattribute change associated with the index point.
 93. A computerreadable medium for controlling execution of a computer system duringpresentation of a media program, the computer readable mediumcomprising: first computer program code means for receiving a mediaprogram including at least one of video content and audio content;second computer program code means for receiving related data correlatedwith the media program for controlling computer system execution duringpresentation of the media program; third computer program code means foridentifying in the related data an attribute change to occur duringpresentation of the media program; fourth computer program code meansfor identifying in the related data an index point associated with theattribute change for triggering the attribute change upon detectingoccurrence of the initiating event during presentation of the mediaprogram; fifth presenting the media program; detecting the initiatingevent associated with the index point and triggering the attributechange associated with the index point.
 94. A system for controllingexecution of a computer system during presentation of a media program,the system comprising: a receiver including: a first componentconfigured to receive a media program including at least one of videocontent and audio content; and a second component configured to receiverelated data correlated with the media program for controlling computersystem execution during presentation of the media program; and aprocessor including: a third component configured to identify in therelated data an attribute change to occur during presentation of themedia program; a fourth component configured to identify in the relateddata an index point associated with the attribute change for triggeringthe attribute change upon detecting occurrence of the initiating eventduring presentation of the media program; a fifth component configuredto present the media program; and a sixth component configured to detectthe initiating event associated with the index point and trigger theattribute change associated with the index point.
 95. A method foremulating execution of a computer system during presentation of a mediaprogram, the method comprising: loading a media program including atleast one of video content and audio content; loading related datacorrelated with the media program for controlling computer systemexecution during presentation of the media program; identifying in therelated data an attribute change to occur during presentation of themedia program; identifying in the related data an index point associatedwith the attribute change for triggering the attribute change upondetecting occurrence of the initiating event during presentation of themedia program; emulating presenting the media program; and detecting theinitiating event associated with the index point and triggering theattribute change associated with the index point.
 96. A computerreadable medium for emulating execution of a computer system duringpresentation of a media program, the computer readable mediumcomprising: first computer program code means for loading a mediaprogram including at least one of video content and audio content;second computer program code means for loading related data correlatedwith the media program for controlling computer system execution duringpresentation of the media program; third computer program code means foridentifying in the related data an attribute change to occur duringpresentation of the media program; fourth computer program code meansfor identifying in the related data an index point associated with theattribute change for triggering the attribute change upon detectingoccurrence of the initiating event during presentation of the mediaprogram; fifth emulating presenting the media program; and detecting theinitiating event associated with the index point and triggering theattribute change associated with the index point.
 97. A system foremulating execution of a computer system during presentation of a mediaprogram, the system comprising: a receiver including: a first componentconfigured to load a media program including at least one of videocontent and audio content; and a second component configured to loadrelated data correlated with the media program for controlling computersystem execution during presentation of the media program; and aprocessor including: a third component configured to identify in therelated data an attribute change to occur during presentation of themedia program; a fourth component configured to identify in the relateddata an index point associated with the attribute change for triggeringthe attribute change upon detecting occurrence of the initiating eventduring presentation of the media program; a fifth component configuredto emulate presentation of the media program; and a sixth componentconfigured to detect the initiating event associated with the indexpoint and trigger the attribute change associated with the index point.